img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Tutoriel sur les listes imbriquées en Python

L’objectif de ce tutoriel est de vous aider à comprendre le fonctionnement des listes imbriquées en Python. Vous apprendrez à créer, parcourir et manipuler ces structures pour organiser vos données de manière efficace. À travers des exemples pratiques, vous serez en mesure d’appliquer cette notion dans vos propres projets de programmation.

Introduction aux listes imbriquées

Les listes imbriquées (ou listes de listes) sont une structure de données fondamentale en Python qui permet de stocker des collections de données organisées hiérarchiquement. Elles sont particulièrement utiles pour représenter des données multidimensionnelles.

Qu'est-ce qu'une liste imbriquée ?

Une liste imbriquée est simplement une liste qui contient d'autres listes comme éléments. Cela permet de créer des structures de données à deux dimensions ou plus, similaires à des matrices ou des tableaux.

definition_listes_imbriquees.py
# Exemple basique d'une liste imbriquée
# Représentation des régions du Maroc et leurs villes principales
regions_maroc = [
    ["Casablanca-Settat", "Casablanca", "Settat", "Mohammédia"],
    ["Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"],
    ["Marrakech-Safi", "Marrakech", "Safi", "El Kelaa des Sraghna"]
]

# Liste imbriquée avec différents types de données
informations_ville = [
    ["Marrakech", 928850, "Tourisme", True],
    ["Tanger", 947952, "Portuaire", True],
    ["Fès", 1112072, "Artisanat", False]
]

# Liste à trois niveaux d'imbrication
universites_maroc = [
    [
        ["Université Mohammed V", "Rabat", ["Droit", "Médecine", "Sciences"]],
        ["Université Hassan II", "Casablanca", ["Ingénierie", "Économie", "Lettres"]]
    ],
    [
        ["Université Cadi Ayyad", "Marrakech", ["Sciences", "Technologie"]],
        ["Université Ibn Tofail", "Kénitra", ["Droit", "Sciences Humaines"]]
    ]
]

print("Liste des régions:", regions_maroc)
print("Type de regions_maroc:", type(regions_maroc))
print("Type du premier élément:", type(regions_maroc[0]))

Pourquoi utiliser des listes imbriquées ?

Les listes imbriquées offrent plusieurs avantages pour organiser et manipuler des données complexes de manière structurée :

avantages_listes_imbriquees.py
# AVANTAGE 1: Représentation de données tabulaires
# Tableau des températures moyennes par ville au Maroc
temperatures_maroc = [
    ["Ville", "Janvier", "Juillet", "Annuelle"],
    ["Casablanca", 12.5, 23.5, 18.5],
    ["Marrakech", 12.0, 29.0, 20.5],
    ["Fès", 10.0, 27.0, 18.0],
    ["Agadir", 14.0, 22.0, 18.0]
]

# AVANTAGE 2: Structure hiérarchique naturelle
# Organisation administrative du Maroc
administration_marocaine = [
    ["Région de l'Oriental", 
        ["Préfecture d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"]],
        ["Province de Jerada", ["Jerada", "Touissit", "Gafait"]]
    ],
    ["Région de Souss-Massa",
        ["Préfecture d'Agadir Ida-Outanane", ["Agadir", "Aït Melloul"]],
        ["Province de Taroudant", ["Taroudant", "Oulad Berhil", "Aoulouz"]]
    ]
]

# AVANTAGE 3: Flexibilité dans le stockage de données hétérogènes
# Informations sur les monuments historiques marocains
monuments_maroc = [
    ["Koutoubia", "Marrakech", 1158, ["Architecture almohade", "Minaret"], True],
    ["Hassan II", "Casablanca", 1993, ["Architecture moderne", "Plus haute mosquée"], True],
    ["Chellah", "Rabat", 1339, ["Site archéologique", "Nécropole"], False]
]

# AVANTAGE 4: Facilité de manipulation avec des boucles
# Calcul de la température moyenne annuelle par ville
print("Températures annuelles par ville:")
for i in range(1, len(temperatures_maroc)):
    ville = temperatures_maroc[i][0]
    temp_annuelle = temperatures_maroc[i][3]
    print(f"- {ville}: {temp_annuelle}°C")

# AVANTAGE 5: Représentation de matrices pour les calculs mathématiques
# Matrice de distances entre villes marocaines (en km)
distances_villes = [
    [0, 240, 580, 320],   # De Casablanca
    [240, 0, 470, 530],    # De Rabat
    [580, 470, 0, 330],    # De Fès
    [320, 530, 330, 0]     # De Marrakech
]

villes = ["Casablanca", "Rabat", "Fès", "Marrakech"]
print(f"\nDistance de Casablanca à Marrakech: {distances_villes[0][3]} km")

Caractéristiques des listes imbriquées en Python

Les listes imbriquées en Python possèdent des particularités importantes à comprendre pour une utilisation efficace :

caracteristiques_listes_imbriquees.py
# CARACTÉRISTIQUE 1: Hétérogénéité des éléments
# Une liste imbriquée peut contenir différents types de données
donnees_heterogenes = [
    ["Maroc", 37, 710850, ["Arabe", "Amazigh"], {"Monnaie": "Dirham"}],
    ["Espagne", 17, 505990, ["Espagnol"], {"Monnaie": "Euro"}]
]

# CARACTÉRISTIQUE 2: Mutabilité
# Les listes imbriquées sont modifiables
produits_marocains = [
    ["Argan", 150.0, "Cosmétique"],
    ["Safran", 25.0, "Épice"],
    ["Couscous", 30.0, "Alimentaire"]
]

# Modification d'un élément dans une sous-liste
produits_marocains[0][1] = 180.0  # Augmentation du prix de l'argan
produits_marocains.append(["Zellige", 200.0, "Artisanat"])  # Ajout d'un produit

# CARACTÉRISTIQUE 3: Attention aux références
# Création problématique avec la multiplication
liste_problematique = [[0]] * 3  # Crée 3 références à la même sous-liste
liste_problematique[0][0] = 5   # Modifie les 3 sous-listes!
print("Liste problématique:", liste_problematique)  # [[5], [5], [5]]


# Solution: utiliser une compréhension de liste
liste_correcte = [[0] for _ in range(3)]
liste_correcte[0][0] = 5
print("Liste correcte:", liste_correcte)  # [[5], [0], [0]]

# CARACTÉRISTIQUE 4: Dimensions variables
# Les sous-listes peuvent avoir des tailles différentes
festivals_maroc = [
    ["Festival des Roses", "Kelaa M'Gouna", "Mai"],
    ["Festival des Cerises", "Sefrou"],  # Mois manquant
    ["Mawazine", "Rabat", "Mai", "Musique", 2001]  # Plus d'infos
]

print("\nProduits marocains mis à jour:")
for produit in produits_marocains:
    print(f"- {produit[0]}: {produit[1]} DH ({produit[2]})")

Créer et initialiser une liste imbriquée en Python

La création de listes imbriquées en Python peut se faire de plusieurs manières, chacune adaptée à des besoins spécifiques. Voyons les différentes méthodes pour définir et initialiser ces structures de données.

Définir une liste de listes

Une liste imbriquée est essentiellement une liste contenant d'autres listes comme éléments. Plusieurs approches permettent de les créer selon le contexte d'utilisation.

definir_listes_imbriquees.py
# MÉTHODE 1: Définition directe avec des crochets
# Liste des régions du Maroc avec leurs villes principales
regions_direct = [
    ["Casablanca-Settat", "Casablanca", "Mohammédia", "Settat"],
    ["Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"],
    ["Marrakech-Safi", "Marrakech", "Safi", "El Kelaa des Sraghna"]
]

# MÉTHODE 2: Construction progressive avec append()
regions_progressive = []
regions_progressive.append(["Tanger-Tétouan-Al Hoceïma", "Tanger", "Tétouan", "Al Hoceïma"])
regions_progressive.append(["Fès-Meknès", "Fès", "Meknès", "Ifrane"])
regions_progressive.append(["Beni Mellal-Khénifra", "Beni Mellal", "Khénifra", "Khouribga"])

# MÉTHODE 3: Utilisation de la multiplication (ATTENTION au piège!)
# Méthode problématique - crée des références à la même liste
matrice_problematique = [[0] * 3] * 4  # 4 lignes, 3 colonnes
matrice_problematique[0][0] = 1  # Modifie toutes les lignes!

# MÉTHODE 4: Compréhension de liste (RECOMMANDÉE)
matrice_correcte = [[0 for _ in range(3)] for _ in range(4)]
matrice_correcte[0][0] = 1  # Modifie seulement la première ligne

# MÉTHODE 5: À partir de données existantes
villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"]
populations = [3350000, 577000, 928000, 1112000, 948000]
villes_avec_population = [[ville, pop] for ville, pop in zip(villes_maroc, populations)]

print("Définition directe:", regions_direct[0])
print("Construction progressive:", regions_progressive[1])
print("Problème multiplication:", matrice_problematique)
print("Solution compréhension:", matrice_correcte)
print("À partir de données:", villes_avec_population)

Exemples simples de listes imbriquées

Voici plusieurs exemples concrets montrant comment utiliser les listes imbriquées dans différents contextes avec des données marocaines.

exemples_simples_listes.py
# EXEMPLE 1: Représentation de données tabulaires
# Tableau des spécialités culinaires par ville
specialites_culinaires = [
    ["Ville", "Spécialité", "Saison", "Prix moyen (DH)"],
    ["Fès", "Pastilla", "Toute l'année", 80],
    ["Marrakech", "Tanjia", "Hiver", 60],
    ["Agadir", "Poisson grillé", "Été", 45],
    ["Casablanca", "Seafood", "Toute l'année", 120]
]

# EXEMPLE 2: Structure hiérarchique - Régions et provinces
administration_maroc = [
    ["Région de l'Oriental", 
        ["Province d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"]],
        ["Province de Jerada", ["Jerada", "Touissit", "Gafait"]],
        ["Province de Berkane", ["Berkane", "Ahfir", "Saïdia"]]
    ],
    ["Région de Drâa-Tafilalet",
        ["Province d'Errachidia", ["Errachidia", "Goulmima", "Tinejdad"]],
        ["Province de Zagora", ["Zagora", "Agdz", "Tamegroute"]]
    ]
]

# EXEMPLE 3: Matrice pour calculs mathématiques
# Distances entre villes marocaines (en km)
distances = [
    [0, 240, 580, 320, 330],   # Casablanca
    [240, 0, 470, 530, 250],    # Rabat
    [580, 470, 0, 330, 650],    # Fès
    [320, 530, 330, 0, 550],     # Marrakech
    [330, 250, 650, 550, 0]      # Tanger
]

# EXEMPLE 4: Données hétérogènes - Informations touristiques
sites_touristiques = [
    ["Jemaa el-Fna", "Marrakech", "Place publique", 1000, True, ["Spectacle", "Gastronomie", "Artisanat"]],
    ["Hassan II", "Casablanca", "Mosquée", 1993, True, ["Architecture", "Religieux"]],
    ["Volubilis", "Meknès", "Site archéologique", -300, False, ["Histoire", "Romaine"]]
]

# EXEMPLE 5: Liste d'étudiants avec notes
etudiants_notes = [
    ["Amina Alami", "Université Cadi Ayyad", [15.5, 18.0, 16.5]],
    ["Youssef Benani", "Université Hassan II", [14.0, 17.5, 19.0]],
    ["Fatima Zahra", "Université Ibn Tofail", [16.0, 15.5, 18.5]]
]

# Affichage des exemples
print("=== SPÉCIALITÉS CULINAIRES ===")
for i in range(1, len(specialites_culinaires)):
    ligne = specialites_culinaires[i]
    print(f"- {ligne[0]}: {ligne[1]} ({ligne[3]} DH)")

print("\n=== DISTANCES ENTRE VILLES ===")
villes = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger"]
print(f"De Casablanca à Marrakech: {distances[0][3]} km")
print(f"De Rabat à Tanger: {distances[1][4]} km")

print("\n=== NOTES DES ÉTUDIANTS ===")
for etudiant in etudiants_notes:
    moyenne = sum(etudiant[2]) / len(etudiant[2])
    print(f"- {etudiant[0]}: moyenne = {moyenne:.2f}")

Méthodes d'initialisation avancées

Pour des cas plus complexes, Python offre des méthodes avancées pour créer et initialiser des listes imbriquées de manière efficace.

initialisation_avancee.py
# MÉTHODE 1: Initialisation avec des valeurs par défaut complexes
# Création d'un calendrier d'événements marocains
def creer_calendrier_mensuel(mois, annee=2024):
    # Crée une liste de 4 semaines avec 7 jours chacune
    return [[{"jour": 0, "evenements": []} for _ in range(7)] for _ in range(4)]

calendrier_janvier = creer_calendrier_mensuel("Janvier")

# MÉTHODE 2: À partir de fichiers ou données externes (simulation)
def charger_donnees_regions():
    # Simulation de données chargées depuis une source externe
    donnees_brutes = [
        "Casablanca-Settat:Casablanca,Mohammédia,Settat,Benslimane",
        "Rabat-Salé-Kénitra:Rabat,Salé,Kénitra,Skhirat",
        "Marrakech-Safi:Marrakech,Safi,El Kelaa,Essaouira"
    ]
    
    regions = []
    for ligne in donnees_brutes:
        nom_region, villes = ligne.split(":")
        liste_villes = villes.split(",")
        regions.append([nom_region] + liste_villes)
    
    return regions

regions_chargees = charger_donnees_regions()

# MÉTHODE 3: Transformation de structures de données
# Conversion d'un dictionnaire en liste imbriquée
universites_dict = {
    "Université Mohammed V": ["Rabat", 1957, ["Droit", "Médecine"]],
    "Université Cadi Ayyad": ["Marrakech", 1978, ["Sciences", "Lettres"]],
    "Université Ibn Tofail": ["Kénitra", 1989, ["Droit", "Sciences"]]
}

# Conversion en liste imbriquée
universites_liste = [[nom] + details for nom, details in universites_dict.items()]

# MÉTHODE 4: Génération avec conditions
# Liste des villes avec population supérieure à 500,000 habitants
villes_maroc = [
    ["Casablanca", 3350000],
    ["Fès", 1112000],
    ["Tanger", 948000],
    ["Marrakech", 928000],
    ["Salé", 890000],
    ["Meknès", 520000],
    ["Rabat", 577000]
]

grandes_villes = [ville for ville in villes_maroc if ville[1] > 500000]

# Affichage des résultats
print("Calendrier créé:", len(calendrier_janvier), "semaines")
print("Régions chargées:", [r[0] for r in regions_chargees])
print("Universités converties:", len(universites_liste))
print("Grandes villes:", [ville[0] for ville in grandes_villes])

Accéder aux éléments d'une liste imbriquée

L'accès aux éléments dans les listes imbriquées nécessite une compréhension de la navigation à travers plusieurs niveaux d'indices. Cette section explique comment manipuler efficacement ces structures complexes.

Utiliser les indices pour naviguer

L'accès aux éléments se fait en chaînant les indices entre crochets. Chaque paire de crochets permet de descendre d'un niveau dans la hiérarchie de la liste.

navigation_indices.py
# Structure de données : Régions du Maroc avec leurs villes et monuments
donnees_maroc = [
    ["Casablanca-Settat", 
        ["Casablanca", ["Mosquée Hassan II", "Corniche", "Place Mohammed V"]],
        ["Mohammédia", ["Plage des Sablettes", "Port"]]
    ],
    ["Marrakech-Safi", 
        ["Marrakech", ["Jemaa el-Fna", "Jardin Majorelle", "Koutoubia"]],
        ["Safi", ["Médina", "Cité Portugaise"]]
    ]
]

# ACCÈS DE BASE - Premier niveau
premiere_region = donnees_maroc[0]
deuxieme_region = donnees_maroc[1]
print("Première région:", premiere_region[0])  # "Casablanca-Settat"
print("Deuxième région:", deuxieme_region[0])   # "Marrakech-Safi"

# ACCÈS DEUXIÈME NIVEAU - Villes d'une région
villes_casablanca_settat = donnees_maroc[0][1:]  # Toutes les villes de la première région
premiere_ville = donnees_maroc[0][1]  # Première ville de la première région
nom_premiere_ville = donnees_maroc[0][1][0]  # Nom de la première ville

print("\nVilles de Casablanca-Settat:", [ville[0] for ville in villes_casablanca_settat])
print("Première ville:", nom_premiere_ville)

# ACCÈS TROISIÈME NIVEAU - Monuments d'une ville
monuments_casablanca = donnees_maroc[0][1][1]  # Monuments de Casablanca
premier_monument = donnees_maroc[0][1][1][0]  # Premier monument de Casablanca

print("\nMonuments de Casablanca:", monuments_casablanca)
print("Premier monument:", premier_monument)

# ACCÈS AVEC INDICES NÉGATIFS
derniere_region = donnees_maroc[-1]  # Dernière région
derniere_ville_derniere_region = donnees_maroc[-1][-1]  # Dernière ville de la dernière région
dernier_monument = donnees_maroc[-1][-1][1][-1]  # Dernier monument de la dernière ville

print("\nAvec indices négatifs:")
print("Dernière région:", derniere_region[0])
print("Dernière ville:", derniere_ville_derniere_region[0])
print("Dernier monument:", dernier_monument)

# ACCÈS AVEC SLICING
premieres_deux_villes = donnees_maroc[0][1:3]  # Premières deux villes de la première région
deux_premiers_monuments = donnees_maroc[0][1][1][:2]  # Deux premiers monuments de Casablanca

print("\nAvec slicing:")
print("Deux premières villes:", [ville[0] for ville in premieres_deux_villes])
print("Deux premiers monuments:", deux_premiers_monuments)

Exemple pratique d'accès à plusieurs niveaux

Voici des exemples concrets montrant comment accéder et manipuler des données complexes dans des listes imbriquées avec des structures marocaines.

acces_pratique.py
# EXEMPLE 1: Système éducatif marocain
systeme_educatif = [
    ["Université Mohammed V", "Rabat", 
        ["Faculté des Sciences", ["Mathématiques", "Physique", "Chimie"]],
        ["Faculté de Médecine", ["Médecine Générale", "Chirurgie", "Pédiatrie"]]
    ],
    ["Université Cadi Ayyad", "Marrakech",
        ["Faculté des Sciences Semlalia", ["Informatique", "Géologie"]],
        ["Faculté des Lettres", ["Arabe", "Français", "Histoire"]]
    ]
]

# Accès aux différentes informations
universite_rabat = systeme_educatif[0]
facultes_marrakech = systeme_educatif[1][2:]
filieres_medecine = systeme_educatif[0][2][1][1]
premiere_filiere_info = systeme_educatif[1][2][1][0]

print("=== SYSTÈME ÉDUCATIF MAROCAIN ===")
print(f"Université de Rabat: {universite_rabat[0]}")
print(f"Facultés à Marrakech: {[fac[0] for fac in facultes_marrakech]}")
print(f"Filières de médecine: {filieres_medecine}")
print(f"Première filière info: {premiere_filiere_info}")

# EXEMPLE 2: Réseau de transport
reseau_transport = [
    ["ONCF", "Train",
        ["Ligne Tanger-Casablanca", ["Tanger", "Kénitra", "Rabat", "Casablanca"], 330, 2.5],
        ["Ligne Fès-Marrakech", ["Fès", "Meknès", "Casablanca", "Marrakech"], 580, 4.0]
    ],
    ["CTM", "Bus",
        ["Rabat-Agadir", ["Rabat", "Casablanca", "Marrakech", "Agadir"], 530, 6.5],
        ["Fès-Tanger", ["Fès", "Oujda", "Tanger"], 450, 5.0]
    ]
]

# Extraction d'informations spécifiques
premiere_ligne_train = reseau_transport[0][2][0]
villes_tanger_casablanca = reseau_transport[0][2][0][1]
distance_fes_marrakech = reseau_transport[0][2][1][2]
duree_rabat_agadir = reseau_transport[1][2][0][3]

print("\n=== RÉSEAU DE TRANSPORT ===")
print(f"Première ligne train: {premiere_ligne_train}")
print(f"Villes Tanger-Casablanca: {villes_tanger_casablanca}")
print(f"Distance Fès-Marrakech: {distance_fes_marrakech} km")
print(f"Durée Rabat-Agadir: {duree_rabat_agadir} heures")

# EXEMPLE 3: Données touristiques complexes
tourisme_maroc = [
    ["Circuit Impérial", 7, ["Rabat", "Fès", "Meknès", "Marrakech"],
        [["Hôtel Tour Hassan", 4, 1200], ["Riad Fès", 5, 1800]]
    ],
    ["Circuit Désert", 5, ["Marrakech", "Ouarzazate", "Zagora", "Merzouga"],
        [["Kasbah Aït Benhaddou", 3, 800], ["Campement Désert", 4, 1500]]
    ]
]

# Accès aux données touristiques
nom_circuit_imperial = tourisme_maroc[0][0]
villes_circuit_desert = tourisme_maroc[1][2]
premier_hotel = tourisme_maroc[0][3][0][0]
prix_campement = tourisme_maroc[1][3][1][2]
duree_circuit = tourisme_maroc[0][1]

print("\n=== TOURISME AU MAROC ===")
print(f"Circuit: {nom_circuit_imperial} ({duree_circuit} jours)")
print(f"Villes du circuit désert: {villes_circuit_desert}")
print(f"Premier hôtel: {premier_hotel}")
print(f"Prix campement: {prix_campement} DH/nuit")

Techniques avancées d'accès

Pour des structures complexes, il est utile de combiner différentes techniques d'accès et de créer des fonctions utilitaires.

techniques_avancees.py
# Structure complexe : Administration territoriale
administration_complexe = [
    ["Région de l'Oriental", 1.5,  # Population en millions
        [
            ["Province d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"], 550000],
            ["Province de Berkane", ["Berkane", "Ahfir", "Saïdia"], 350000]
        ]
    ],
    ["Région de Souss-Massa", 2.7,
        [
            ["Préfecture d'Agadir Ida-Outanane", ["Agadir", "Aït Melloul"], 600000],
            ["Province de Taroudant", ["Taroudant", "Oulad Berhil"], 800000]
        ]
    ]
]

# FONCTION UTILITAIRE : Accès sécurisé avec gestion d'erreurs
def acces_securise(liste_imbriquee, *indices):
    """Accède à un élément de manière sécurisée avec gestion des IndexError"""
    element = liste_imbriquee
    try:
        for index in indices:
            element = element[index]
        return element
    except (IndexError, TypeError):
        return None

# FONCTION : Extraire toutes les villes d'une région
def extraire_villes_region(administration, nom_region):
    """Extrait toutes les villes d'une région donnée"""
    for region in administration:
        if region[0] == nom_region:
            villes = []
            for province in region[2]:
                villes.extend(province[1])
            return villes
    return []

# FONCTION : Calculer la population totale d'une région
def population_totale_region(administration, nom_region):
    """Calcule la population totale d'une région"""
    for region in administration:
        if region[0] == nom_region:
            population_totale = 0
            for province in region[2]:
                population_totale += province[2]
            return population_totale
    return 0

# UTILISATION DES FONCTIONS
print("=== TECHNIQUES AVANCÉES ===")

# Accès sécurisé
premiere_province = acces_securise(administration_complexe, 0, 2, 0)
ville_inexistante = acces_securise(administration_complexe, 0, 2, 5, 10)  # Indices invalides

print(f"Première province de l'Oriental: {premiere_province[0]}")
print(f"Accès à élément inexistant: {ville_inexistante}")

# Extraction de données
villes_oriental = extraire_villes_region(administration_complexe, "Région de l'Oriental")
population_souss = population_totale_region(administration_complexe, "Région de Souss-Massa")

print(f"\nVilles de l'Oriental: {villes_oriental}")
print(f"Population de Souss-Massa: {population_souss:,} habitants")

# ACCÈS AVEC DÉBALLAGE
for region in administration_complexe:
    nom_region, population_region, provinces = region
    print(f"\n{nom_region}:")
    for province in provinces:
        nom_province, villes, population = province
        print(f"  - {nom_province}: {population:,} habitants")

Parcourir une liste imbriquée

Le parcours des listes imbriquées est essentiel pour traiter et analyser des données complexes. Python offre plusieurs approches, des boucles imbriquées classiques aux compréhensions de liste plus élégantes.

Utiliser des boucles imbriquées

Les boucles imbriquées sont la méthode la plus intuitive pour parcourir des listes imbriquées. Elles permettent un contrôle précis sur chaque niveau d'imbrication.

boucles_imbriquees.py
# Structure : Régions du Maroc avec villes et monuments
regions_maroc = [
    ["Casablanca-Settat", 
        ["Casablanca", ["Mosquée Hassan II", "Corniche", "Place Mohammed V"]],
        ["Mohammédia", ["Plage des Sablettes", "Port"]]
    ],
    ["Marrakech-Safi", 
        ["Marrakech", ["Jemaa el-Fna", "Jardin Majorelle", "Koutoubia"]],
        ["Safi", ["Médina", "Cité Portugaise"]]
    ],
    ["Rabat-Salé-Kénitra",
        ["Rabat", ["Tour Hassan", "Kasbah des Oudayas", "Chellah"]],
        ["Salé", ["Médina", "Grande Mosquée"]]
    ]
]

# PARCOURS COMPLET - 3 niveaux d'imbrication
print("=== PARCOURS COMPLÈT DES RÉGIONS ===")
for region in regions_maroc:
    nom_region = region[0]
    print(f"\n?️  Région: {nom_region}")
    
    # Parcours des villes (niveau 2)
    for ville_info in region[1:]:
        nom_ville = ville_info[0]
        monuments = ville_info[1]
        print(f"  ?️  Ville: {nom_ville}")
        
        # Parcours des monuments (niveau 3)
        for monument in monuments:
            print(f"    ? Monument: {monument}")

# PARCOURS AVEC DÉCOMPTAGE
print("\n" + "="*50)
print("=== STATISTIQUES PAR RÉGION ===")
for i, region in enumerate(regions_maroc, 1):
    nom_region = region[0]
    nb_villes = len(region) - 1  # -1 pour le nom de région
    total_monuments = 0
    
    for ville_info in region[1:]:
        total_monuments += len(ville_info[1])
    
    print(f"{i}. {nom_region}: {nb_villes} villes, {total_monuments} monuments")

# PARCOURS AVEC FILTRES
print("\n" + "="*50)
print("=== VILLES AVEC PLUS DE 2 MONUMENTS ===")
for region in regions_maroc:
    nom_region = region[0]
    
    for ville_info in region[1:]:
        nom_ville = ville_info[0]
        monuments = ville_info[1]
        
        if len(monuments) > 2:
            print(f"? {nom_ville} ({nom_region}): {len(monuments)} monuments")
            for monument in monuments:
                print(f"   - {monument}")

# EXEMPLE PRATIQUE : Système universitaire
universites = [
    ["Université Mohammed V", "Rabat",
        ["Faculté des Sciences", ["Mathématiques", "Physique", "Chimie"]],
        ["Faculté de Médecine", ["Médecine Générale", "Chirurgie"]]
    ],
    ["Université Cadi Ayyad", "Marrakech",
        ["Faculté des Sciences Semlalia", ["Informatique", "Géologie"]],
        ["Faculté des Lettres", ["Arabe", "Français"]]
    ]
]

print("\n" + "="*50)
print("=== SYSTÈME UNIVERSITAIRE MAROCAIN ===")
for universite in universites:
    nom_univ, ville, facultes = universite
    print(f"\n? {nom_univ} - {ville}")
    
    for faculte in facultes:
        nom_fac, filieres = faculte
        print(f"  ? {nom_fac}:")
        
        for filiere in filieres:
            print(f"    • {filiere}")

Parcours avec compréhension de liste

Les compréhensions de liste offrent une syntaxe concise et efficace pour parcourir et transformer des listes imbriquées en une seule ligne de code.

comprehension_liste.py
# Données : Produits artisanaux marocains par région
artisanat_maroc = [
    ["Fès", ["Zellige", "Brodery", "Cuir"], [150, 200, 300]],
    ["Marrakech", ["Tapis", "Poterie", "Lanterne"], [500, 80, 120]],
    ["Essaouira", ["Marqueterie", "Argan"], [250, 180]],
    ["Tétouan", ["Céramique", "Textile"], [90, 150]]
]

# COMPRÉHENSION SIMPLE : Extraire tous les noms de villes
villes_artisanales = [ville[0] for ville in artisanat_maroc]
print("Villes artisanales:", villes_artisanales)

# COMPRÉHENSION IMBRIQUÉE : Tous les produits artisanaux
tous_produits = [produit for ville in artisanat_maroc for produit in ville[1]]
print("Tous les produits:", tous_produits)

# COMPRÉHENSION AVEC CONDITION : Villes avec plus de 2 produits
villes_riches = [ville[0] for ville in artisanat_maroc if len(ville[1]) > 2]
print("Villes avec +2 produits:", villes_riches)

# COMPRÉHENSION COMPLEXE : Produits avec leurs prix
produits_avec_prix = [(ville[0], produit, prix) 
                     for ville in artisanat_maroc 
                     for produit, prix in zip(ville[1], ville[2])]
print("\nProduits avec prix:")
for ville, produit, prix in produits_avec_prix:
    print(f"  {ville}: {produit} - {prix} DH")

# COMPRÉHENSION POUR CALCULS : Prix moyen par ville
prix_moyen_par_ville = [(ville[0], sum(ville[2]) / len(ville[2])) 
                       for ville in artisanat_maroc]
print("\nPrix moyen par ville:")
for ville, prix_moyen in prix_moyen_par_ville:
    print(f"  {ville}: {prix_moyen:.0f} DH")

# EXEMPLE AVANCÉ : Système de notation des étudiants
etudiants = [
    ["Amina Alami", "Université Cadi Ayyad", [15.5, 18.0, 16.5]],
    ["Youssef Benani", "Université Hassan II", [14.0, 17.5, 19.0]],
    ["Fatima Zahra", "Université Ibn Tofail", [16.0, 15.5, 18.5]],
    ["Karim Amrani", "Université Mohammed V", [12.5, 14.0, 13.5]]
]

# Moyennes des étudiants avec compréhension
moyennes_etudiants = [(etudiant[0], sum(etudiant[2]) / len(etudiant[2])) 
                     for etudiant in etudiants]

# Étudiants avec mention (moyenne >= 16)
etudiants_mention = [nom for nom, moyenne in moyennes_etudiants if moyenne >= 16]

# Meilleure note par étudiant
meilleures_notes = [(etudiant[0], max(etudiant[2])) for etudiant in etudiants]

print("\n" + "="*50)
print("=== RÉSULTATS DES ÉTUDIANTS ===")
print("\nMoyennes des étudiants:")
for nom, moyenne in moyennes_etudiants:
    print(f"  {nom}: {moyenne:.2f}/20")

print(f"\nÉtudiants avec mention: {etudiants_mention}")

print("\nMeilleures notes:")
for nom, meilleure_note in meilleures_notes:
    print(f"  {nom}: {meilleure_note}/20")

# COMPRÉHENSION POUR CRÉER UNE NOUVELLE STRUCTURE
# Transformation : étudiants avec statut (Admis/Redoublant)
etudiants_avec_statut = [
    [etudiant[0], etudiant[1], etudiant[2], 
     "Admis" if (sum(etudiant[2]) / len(etudiant[2])) >= 10 else "Redoublant"]
    for etudiant in etudiants
]

print("\nStatut des étudiants:")
for etudiant in etudiants_avec_statut:
    print(f"  {etudiant[0]} - {etudiant[3]}")

Techniques avancées de parcours

Pour des structures très complexes, il est utile de combiner différentes techniques et de créer des fonctions récursives ou utilitaires.

parcours_avances.py
# Structure complexe : Organisation administrative marocaine
administration_maroc = [
    ["Région de l'Oriental", 1.5,  # Population en millions
        [
            ["Province d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"], 550000],
            ["Province de Berkane", ["Berkane", "Ahfir", "Saïdia"], 350000]
        ]
    ],
    ["Région de Souss-Massa", 2.7,
        [
            ["Préfecture d'Agadir Ida-Outanane", ["Agadir", "Aït Melloul"], 600000],
            ["Province de Taroudant", ["Taroudant", "Oulad Berhil", "Aoulouz"], 800000]
        ]
    ]
]

# FONCTION RÉCURSIVE : Aplatir une liste imbriquée
def aplanir_liste(liste_imbriquee):
    """Aplatit récursivement une liste imbriquée"""
    resultat = []
    for element in liste_imbriquee:
        if isinstance(element, list):
            resultat.extend(aplanir_liste(element))
        else:
            resultat.append(element)
    return resultat

# FONCTION : Parcours avec traitement conditionnel
def parcours_conditionnel(administration, seuil_population=500000):
    """Parcourt l'administration et filtre par seuil de population"""
    resultats = []
    
    for region in administration:
        nom_region, pop_region, provinces = region
        
        for province in provinces:
            nom_province, villes, population = province
            
            if population >= seuil_population:
                resultats.append({
                    'region': nom_region,
                    'province': nom_province,
                    'population': population,
                    'villes': villes
                })
    
    return resultats

# FONCTION : Génération de rapports
def generer_rapport_administratif(administration):
    """Génère un rapport complet de l'administration"""
    rapport = {
        'total_regions': len(administration),
        'total_provinces': 0,
        'total_villes': 0,
        'population_totale': 0,
        'regions': []
    }
    
    for region in administration:
        nom_region, pop_region, provinces = region
        info_region = {
            'nom': nom_region,
            'population_region': pop_region,
            'nb_provinces': len(provinces),
            'provinces': []
        }
        
        for province in provinces:
            nom_province, villes, population = province
            info_province = {
                'nom': nom_province,
                'population': population,
                'nb_villes': len(villes),
                'villes': villes
            }
            
            info_region['provinces'].append(info_province)
            rapport['total_provinces'] += 1
            rapport['total_villes'] += len(villes)
            rapport['population_totale'] += population
        
        rapport['regions'].append(info_region)
    
    return rapport

# UTILISATION DES FONCTIONS AVANCÉES
print("=== TECHNIQUES AVANCÉES DE PARCOURS ===")

# Aplanissement
elements_aplatis = aplanir_liste(administration_maroc)
print(f"\nÉléments aplatis ({len(elements_aplatis)} éléments):")
print(elements_aplatis[:10])  # Affiche les 10 premiers

# Parcours conditionnel
provinces_peuplees = parcours_conditionnel(administration_maroc, 500000)
print(f"\nProvinces avec +500,000 habitants:")
for province in provinces_peuplees:
    print(f"  {province['province']} ({province['region']}): {province['population']:,} hab.")

# Rapport administratif
rapport = generer_rapport_administratif(administration_maroc)
print(f"\n? RAPPORT ADMINISTRATIF:")
print(f"Régions: {rapport['total_regions']}")
print(f"Provinces: {rapport['total_provinces']}")
print(f"Villes: {rapport['total_villes']}")
print(f"Population totale: {rapport['population_totale']:,} habitants")

# PARCOURS AVEC ITERTOOLS
import itertools

# Toutes les combinaisons de régions et provinces
combinaisons = list(itertools.chain.from_iterable(
    [[(region[0], province[0]) for province in region[2]] 
     for region in administration_maroc]
))

print(f"\nCombinaisons régions-provinces ({len(combinaisons)}):")
for region, province in combinaisons:
    print(f"  {region} → {province}")

Manipuler et modifier les listes imbriquées

La manipulation des listes imbriquées nécessite une compréhension précise de la structure hiérarchique. Cette section couvre les opérations essentielles d'ajout, de suppression et de modification d'éléments.

Ajouter ou supprimer des éléments

L'ajout et la suppression d'éléments dans des listes imbriquées peuvent se faire à différents niveaux de la hiérarchie, en utilisant les méthodes standards des listes Python.

ajout_suppression.py
# Structure initiale : Régions du Maroc avec villes
regions_maroc = [
    ["Casablanca-Settat", 
        ["Casablanca", ["Mosquée Hassan II", "Corniche"]],
        ["Mohammédia", ["Plage des Sablettes"]]
    ],
    ["Marrakech-Safi", 
        ["Marrakech", ["Jemaa el-Fna", "Jardin Majorelle"]]
    ]
]

print("=== STRUCTURE INITIALE ===")
for region in regions_maroc:
    print(f"{region[0]}: {[ville[0] for ville in region[1:]]}")

# AJOUT D'ÉLÉMENTS
print("\n" + "="*50)
print("=== AJOUT D'ÉLÉMENTS ===")

# 1. Ajouter une nouvelle région (niveau 1)
nouvelle_region = ["Rabat-Salé-Kénitra", 
                  ["Rabat", ["Tour Hassan", "Kasbah des Oudayas"]],
                  ["Salé", ["Médina"]]]
regions_maroc.append(nouvelle_region)
print("✅ Nouvelle région ajoutée: Rabat-Salé-Kénitra")

# 2. Ajouter une ville à une région existante (niveau 2)
regions_maroc[0].append(["Settat", ["Médina", "Place Mohammed V"]])
print("✅ Nouvelle ville ajoutée à Casablanca-Settat: Settat")

# 3. Ajouter un monument à une ville existante (niveau 3)
regions_maroc[1][1][1].append("Koutoubia")
print("✅ Nouveau monument ajouté à Marrakech: Koutoubia")

# 4. Insertion à une position spécifique
regions_maroc[0][1][1].insert(1, "Place Mohammed V")
print("✅ Monument inséré à position 1 dans Casablanca")

# SUPPRESSION D'ÉLÉMENTS
print("\n" + "="*50)
print("=== SUPPRESSION D'ÉLÉMENTS ===")

# 1. Supprimer le dernier monument d'une ville (niveau 3)
dernier_monument = regions_maroc[0][1][1].pop()
print(f"✅ Dernier monument supprimé de Casablanca: {dernier_monument}")

# 2. Supprimer un monument spécifique par valeur
if "Plage des Sablettes" in regions_maroc[0][2][1]:
    regions_maroc[0][2][1].remove("Plage des Sablettes")
    print("✅ Monument supprimé de Mohammédia: Plage des Sablettes")

# 3. Supprimer une ville par index (niveau 2)
ville_supprimee = regions_maroc[0].pop(2)
print(f"✅ Ville supprimée de Casablanca-Settat: {ville_supprimee[0]}")

# 4. Supprimer une région entière (niveau 1)
region_supprimee = regions_maroc.pop(2)
print(f"✅ Région supprimée: {region_supprimee[0]}")

# 5. Vider tous les monuments d'une ville
regions_maroc[0][1][1].clear()
print("✅ Tous les monuments de Casablanca supprimés")

# AFFICHAGE FINAL
print("\n" + "="*50)
print("=== STRUCTURE FINALE ===")
for i, region in enumerate(regions_maroc, 1):
    print(f"\n{i}. {region[0]}:")
    for ville in region[1:]:
        print(f"   - {ville[0]}: {ville[1]}")

# EXEMPLE PRATIQUE : Gestion d'inventaire de produits artisanaux
inventaire_artisanal = [
    ["Fès", 
        ["Zellige", 50, 150.0],
        ["Brodery", 30, 200.0]
    ],
    ["Marrakech",
        ["Tapis", 20, 500.0],
        ["Poterie", 40, 80.0]
    ]
]

print("\n" + "="*50)
print("=== GESTION D'INVENTAIRE ARTISANAL ===")

# Ajouter un nouveau produit à Fès
inventaire_artisanal[0].append(["Cuir", 25, 300.0])
print("✅ Nouveau produit ajouté à Fès: Cuir")

# Supprimer un produit épuisé
for i, produit in enumerate(inventaire_artisanal[1][1:]):
    if produit[1] == 0:  # Quantité épuisée
        produit_supprime = inventaire_artisanal[1].pop(i+1)
        print(f"✅ Produit épuisé supprimé: {produit_supprime[0]}")

print("\nInventaire final:")
for ville in inventaire_artisanal:
    print(f"\n{ville[0]}:")
    for produit in ville[1:]:
        print(f"  - {produit[0]}: {produit[1]} unités, {produit[2]} DH")

Modifier une valeur spécifique

La modification d'éléments spécifiques dans des listes imbriquées nécessite une navigation précise vers l'élément cible. Plusieurs techniques permettent d'effectuer ces modifications efficacement.

modification_valeurs.py
# Structure : Système de réservation hôtelière au Maroc
hotels_maroc = [
    ["Marrakech",
        ["La Mamounia", 5, 2500.0, 10],  # [nom, étoiles, prix, chambres_disponibles]
        ["Riad Dar Anika", 4, 800.0, 5]
    ],
    ["Fès",
        ["Riad Fès", 5, 1800.0, 8],
        ["Palais Faraj", 5, 2200.0, 12]
    ],
    ["Casablanca",
        ["Four Seasons", 5, 3000.0, 15],
        ["Hyatt Regency", 4, 1200.0, 20]
    ]
]

print("=== SYSTÈME DE RÉSERVATION HÔTELIÈRE ===")
print("État initial:")
for ville in hotels_maroc:
    print(f"\n{ville[0]}:")
    for hotel in ville[1:]:
        print(f"  - {hotel[0]} ({hotel[1]}★): {hotel[2]} DH, {hotel[3]} chambres")

# MODIFICATIONS DIRECTES PAR INDICES
print("\n" + "="*50)
print("=== MODIFICATIONS DIRECTES ===")

# 1. Augmenter le prix d'un hôtel spécifique
hotels_maroc[0][1][2] = 2800.0  # La Mamounia
print("✅ Prix de La Mamounia augmenté à 2800 DH")

# 2. Réduire les chambres disponibles après réservation
hotels_maroc[1][1][3] -= 2  # Riad Fès
print("✅ 2 chambres réservées à Riad Fès")

# 3. Changer la classification d'un hôtel
hotels_maroc[2][2][1] = 5  # Hyatt Regency devient 5 étoiles
print("✅ Hyatt Regency promu 5 étoiles")

# MODIFICATIONS AVEC RECHERCHE
print("\n" + "="*50)
print("=== MODIFICATIONS AVEC RECHERCHE ===")

# Fonction pour trouver et modifier un hôtel
def modifier_prix_hotel(hotels, nom_hotel, nouveau_prix):
    """Modifie le prix d'un hôtel spécifique"""
    for ville in hotels:
        for hotel in ville[1:]:
            if hotel[0] == nom_hotel:
                ancien_prix = hotel[2]
                hotel[2] = nouveau_prix
                return True, ancien_prix
    return False, 0

# Appliquer une promotion sur Palais Faraj
succes, ancien_prix = modifier_prix_hotel(hotels_maroc, "Palais Faraj", 1900.0)
if succes:
    print(f"✅ Promotion appliquée à Palais Faraj: {ancien_prix} → 1900 DH")

# MODIFICATIONS EN MASSE
print("\n" + "="*50)
print("=== MODIFICATIONS EN MASSE ===")

# Augmenter tous les prix de 10%
for ville in hotels_maroc:
    for hotel in ville[1:]:
        hotel[2] *= 1.10  # +10%
print("✅ Tous les prix augmentés de 10%")

# Réinitialiser les chambres disponibles pour les hôtels 5 étoiles
for ville in hotels_maroc:
    for hotel in ville[1:]:
        if hotel[1] == 5:
            hotel[3] = 15  # Réinitialiser à 15 chambres
print("✅ Chambres réinitialisées pour tous les hôtels 5 étoiles")

# AFFICHAGE FINAL
print("\n" + "="*50)
print("=== ÉTAT FINAL DU SYSTÈME ===")
for ville in hotels_maroc:
    print(f"\n{ville[0]}:")
    for hotel in ville[1:]:
        print(f"  - {hotel[0]} ({hotel[1]}★): {hotel[2]:.0f} DH, {hotel[3]} chambres")

# EXEMPLE AVANCÉ : Gestion des notes d'étudiants
etudiants_notes = [
    ["Amina Alami", "Université Cadi Ayyad", 
        [["Mathématiques", 15.5], ["Physique", 18.0], ["Chimie", 16.5]]
    ],
    ["Youssef Benani", "Université Hassan II", 
        [["Mathématiques", 14.0], ["Physique", 17.5], ["Informatique", 19.0]]
    ]
]

print("\n" + "="*50)
print("=== GESTION DES NOTES D'ÉTUDIANTS ===")

# Corriger une note spécifique
for etudiant in etudiants_notes:
    if etudiant[0] == "Amina Alami":
        for note in etudiant[2]:
            if note[0] == "Mathématiques":
                note[1] = 16.0  # Correction
                print(f"✅ Note de Mathématiques corrigée pour Amina Alami: 16.0/20")

# Ajouter des points bonus pour tous les étudiants
for etudiant in etudiants_notes:
    for note in etudiant[2]:
        note[1] = min(20, note[1] + 0.5)  # Bonus de 0.5 point
print("✅ 0.5 point bonus ajouté à toutes les notes")

print("\nNotes finales:")
for etudiant in etudiants_notes:
    print(f"\n{etudiant[0]} ({etudiant[1]}):")
    for note in etudiant[2]:
        print(f"  - {note[0]}: {note[1]}/20")

Techniques avancées de manipulation

Pour des opérations complexes, il est utile de créer des fonctions spécialisées qui encapsulent la logique de manipulation des listes imbriquées.

manipulation_avancee.py
# Structure : Réseau de transport marocain
reseau_transport = [
    ["ONCF", "Train",
        ["Tanger-Casablanca", ["Tanger", "Kénitra", "Rabat", "Casablanca"], 330, 2.5],
        ["Fès-Marrakech", ["Fès", "Meknès", "Casablanca", "Marrakech"], 580, 4.0]
    ],
    ["CTM", "Bus",
        ["Rabat-Agadir", ["Rabat", "Casablanca", "Marrakech", "Agadir"], 530, 6.5],
        ["Fès-Tanger", ["Fès", "Oujda", "Tanger"], 450, 5.0]
    ]
]

# FONCTION : Ajouter une nouvelle ligne de transport
def ajouter_ligne_transport(reseau, compagnie, type_transport, nom_ligne, villes, distance, duree):
    """Ajoute une nouvelle ligne de transport au réseau"""
    for transport in reseau:
        if transport[0] == compagnie and transport[1] == type_transport:
            nouvelle_ligne = [nom_ligne, villes, distance, duree]
            transport.append(nouvelle_ligne)
            return True
    
    # Si la compagnie n'existe pas, la créer
    nouvelle_compagnie = [compagnie, type_transport, [nom_ligne, villes, distance, duree]]
    reseau.append(nouvelle_compagnie)
    return True

# FONCTION : Supprimer une ligne par nom
def supprimer_ligne_transport(reseau, nom_ligne):
    """Supprime une ligne de transport par son nom"""
    for transport in reseau:
        for i in range(len(transport) - 1, 1, -1):  # Parcours inverse
            if transport[i][0] == nom_ligne:
                ligne_supprimee = transport.pop(i)
                return ligne_supprimee
    return None

# FONCTION : Mettre à jour la durée d'un trajet
def mettre_a_jour_duree(reseau, nom_ligne, nouvelle_duree):
    """Met à jour la durée d'une ligne de transport"""
    for transport in reseau:
        for ligne in transport[2:]:
            if ligne[0] == nom_ligne:
                ancienne_duree = ligne[3]
                ligne[3] = nouvelle_duree
                return ancienne_duree
    return None

# UTILISATION DES FONCTIONS AVANCÉES
print("=== MANIPULATION AVANCÉE DU RÉSEAU DE TRANSPORT ===")

# Ajouter une nouvelle ligne
ajouter_ligne_transport(reseau_transport, "ONCF", "Train", "Casablanca-Agadir", 
                      ["Casablanca", "Marrakech", "Agadir"], 420, 3.5)
print("✅ Nouvelle ligne ajoutée: Casablanca-Agadir")

# Ajouter une nouvelle compagnie
ajouter_ligne_transport(reseau_transport, "Supratours", "Bus", "Marrakech-Zagora", 
                      ["Marrakech", "Ouarzazate", "Zagora"], 350, 5.0)
print("✅ Nouvelle compagnie et ligne ajoutées: Supratours")

# Supprimer une ligne
ligne_supprimee = supprimer_ligne_transport(reseau_transport, "Fès-Tanger")
if ligne_supprimee:
    print(f"✅ Ligne supprimée: {ligne_supprimee[0]}")

# Mettre à jour une durée
ancienne_duree = mettre_a_jour_duree(reseau_transport, "Rabat-Agadir", 7.0)
if ancienne_duree:
    print(f"✅ Durée mise à jour pour Rabat-Agadir: {ancienne_duree} → 7.0 heures")

# AFFICHAGE FINAL
print("\n" + "="*50)
print("=== RÉSEAU DE TRANSPORT FINAL ===")
for transport in reseau_transport:
    print(f"\n{transport[0]} ({transport[1]}):")
    for ligne in transport[2:]:
        print(f"  - {ligne[0]}: {ligne[1]} | {ligne[2]}km, {ligne[3]}h")

Exemples pratiques d'utilisation

Les listes imbriquées trouvent leur utilité dans de nombreux scénarios réels. Cette section présente deux cas d'usage fondamentaux : la représentation de matrices pour les calculs mathématiques et le stockage de données complexes comme les systèmes de gestion scolaire.

Représenter une matrice

Les matrices sont parfaitement représentées par des listes imbriquées, où chaque sous-liste correspond à une ligne de la matrice. Cette structure est idéale pour les opérations mathématiques et les traitements de données tabulaires.

matrices_maroc.py
# EXEMPLE 1: Matrice de distances entre villes marocaines (en km)
			distances_villes = [
			    #         Casa  Rabat  Fès   Marrak  Tanger Agadir
			    [0,     240,   580,   320,   330,    470],   # Casablanca
			    [240,   0,     470,   530,   250,    530],   # Rabat
			    [580,   470,   0,     330,   650,    720],   # Fès
			    [320,   530,   330,   0,     550,    230],   # Marrakech
			    [330,   250,   650,   550,   0,      680],   # Tanger
			    [470,   530,   720,   230,   680,    0]     # Agadir
			]
			
			villes = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger", "Agadir"]
			
			print("=== MATRICE DE DISTANCES ENTRE VILLES MAROCAINES ===")
			print("Villes:", villes)
			print("\nMatrice des distances (km):")
			for i in range(len(distances_villes)):
			    print(f"{villes[i]:<12}", end="")
			    for j in range(len(distances_villes[i])):
			        print(f"{distances_villes[i][j]:<6}", end="")
			    print()
			
			# Opérations sur la matrice
			print("\n" + "="*50)
			print("=== OPÉRATIONS SUR LA MATRICE ===")
			
			# Distance entre deux villes spécifiques
			ville_depart = "Casablanca"
			ville_arrivee = "Marrakech"
			i = villes.index(ville_depart)
			j = villes.index(ville_arrivee)
			distance = distances_villes[i][j]
			print(f"Distance {ville_depart} → {ville_arrivee}: {distance} km")
			
			# Ville la plus proche d'une ville donnée (hors elle-même)
			ville_reference = "Fès"
			idx_ref = villes.index(ville_reference)
			distances_from_ref = distances_villes[idx_ref]
			# Exclure la distance à elle-même (0)
			distances_filtrees = [d for d in distances_from_ref if d > 0]
			plus_proche_distance = min(distances_filtrees)
			idx_plus_proche = distances_from_ref.index(plus_proche_distance)
			ville_plus_proche = villes[idx_plus_proche]
			print(f"Ville la plus proche de {ville_reference}: {ville_plus_proche} ({plus_proche_distance} km)")
			
			# EXEMPLE 2: Matrice de production agricole par région (tonnes)
			production_agricole = [
			    #         Blé   Orge  Olives Agrumes  Dates
			    [120000, 80000, 15000,  50000,   2000],   # Chaouia-Ouardigha
			    [80000,  60000, 25000,  30000,   5000],   # Marrakech-Safi
			    [50000,  40000, 40000,  15000,   8000],   # Fès-Meknès
			    [30000,  20000, 10000,  80000,   12000],  # Souss-Massa
			    [15000,  10000, 5000,   20000,   15000]   # Drâa-Tafilalet
			]
			
			regions_agricoles = ["Chaouia-Ouardigha", "Marrakech-Safi", "Fès-Meknès", 
			                    "Souss-Massa", "Drâa-Tafilalet"]
			cultures = ["Blé", "Orge", "Olives", "Agrumes", "Dates"]
			
			print("\n" + "="*50)
			print("=== PRODUCTION AGRICOLE PAR RÉGION (tonnes) ===")
			
			# Production totale par culture
			production_totale_culture = []
			for j in range(len(cultures)):
			    total = 0
			    for i in range(len(regions_agricoles)):
			        total += production_agricole[i][j]
			    production_totale_culture.append(total)
			
			print("\nProduction totale par culture:")
			for culture, production in zip(cultures, production_totale_culture):
			    print(f"  {culture}: {production:,} tonnes")
			
			# Région avec la plus grande production totale
			production_par_region = []
			for i in range(len(regions_agricoles)):
			    total_region = sum(production_agricole[i])
			    production_par_region.append(total_region)
			
			max_production = max(production_par_region)
			idx_max = production_par_region.index(max_production)
			region_max = regions_agricoles[idx_max]
			
			print(f"\nRégion la plus productive: {region_max} ({max_production:,} tonnes)")
			
			# EXEMPLE 3: Matrice d'adjacence pour réseau routier
			# 1 = connexion directe, 0 = pas de connexion directe
			reseau_routier = [
			    #      Casa Rabat Fès  Marrak Tanger
			    [0,    1,    1,    1,     1],      # Casablanca
			    [1,    0,    1,    1,     1],      # Rabat
			    [1,    1,    0,    1,     0],      # Fès
			    [1,    1,    1,    0,     0],      # Marrakech
			    [1,    1,    0,    0,     0]       # Tanger
			]
			
			villes_reseau = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger"]
			
			print("\n" + "="*50)
			print("=== RÉSEAU ROUTIER (matrice d'adjacence) ===")
			
			# Villes connectées à Casablanca
			ville_centrale = "Casablanca"
			idx_centrale = villes_reseau.index(ville_centrale)
			connexions = reseau_routier[idx_centrale]
			villes_connectees = [villes_reseau[i] for i in range(len(connexions)) 
			                    if connexions[i] == 1 and i != idx_centrale]
			
			print(f"\nVilles directement connectées à {ville_centrale}: {villes_connectees}")
			
			# Degré de connectivité de chaque ville
			print("\nDegré de connectivité des villes:")
			for i in range(len(villes_reseau)):
			    degre = sum(reseau_routier[i]) - reseau_routier[i][i]  # Exclure la boucle sur soi
			    print(f"  {villes_reseau[i]}: {degre} connexion(s)")

Stocker des données complexes (ex. élèves et notes)

Les listes imbriquées excellent dans le stockage de données structurées complexes, comme les systèmes de gestion scolaire où chaque élève possède plusieurs notes et informations personnelles.

systeme_scolaire.py
# SYSTÈME DE GESTION SCOLAIRE MAROCAIN
			
			# Structure : [Nom, Prénom, École, Classe, [Liste des matières avec notes]]
			eleves_maroc = [
			    ["Alami", "Amina", "Lycée Mohammed V", "Terminale Sciences",
			        [["Mathématiques", [16.5, 15.0, 17.5]],
			         ["Physique-Chimie", [14.0, 16.5, 15.0]],
			         ["SVT", [18.0, 17.0, 16.5]],
			         ["Philosophie", [13.5, 14.0]]]
			    ],
			    ["Benani", "Youssef", "Lycée Hassan II", "Terminale Sciences",
			        [["Mathématiques", [12.0, 14.5, 13.0]],
			         ["Physique-Chimie", [15.5, 16.0, 14.5]],
			         ["SVT", [11.5, 13.0, 12.5]],
			         ["Philosophie", [16.0, 15.5]]]
			    ],
			    ["Zahra", "Fatima", "Lycée Moulay Youssef", "Terminale Lettres",
			        [["Arabe", [18.5, 17.0, 19.0]],
			         ["Français", [16.0, 15.5, 17.5]],
			         ["Histoire-Géo", [14.5, 16.0, 15.0]],
			         ["Philosophie", [17.0, 18.5]]]
			    ],
			    ["Amrani", "Karim", "Lycée Mohammed V", "Terminale Sciences",
			        [["Mathématiques", [19.0, 18.5, 17.0]],
			         ["Physique-Chimie", [17.5, 16.0, 18.0]],
			         ["SVT", [15.0, 16.5, 14.5]],
			         ["Philosophie", [13.0, 14.5]]]
			    ]
			]
			
			print("=== SYSTÈME DE GESTION SCOLAIRE MAROCAIN ===")
			print("Données des élèves:")
			for eleve in eleves_maroc:
			    nom, prenom, ecole, classe, matieres = eleve
			    print(f"\n? {prenom} {nom}")
			    print(f"   École: {ecole}")
			    print(f"   Classe: {classe}")
			    print(f"   Matières:")
			    for matiere in matieres:
			        nom_matiere, notes = matiere
			        moyenne = sum(notes) / len(notes)
			        print(f"     - {nom_matiere}: {notes} (moyenne: {moyenne:.2f}/20)")
			
			# CALCULS ET STATISTIQUES
			print("\n" + "="*50)
			print("=== STATISTIQUES ET ANALYSES ===")
			
			# 1. Moyenne générale par élève
			print("\n? MOYENNES GÉNÉRALES DES ÉLÈVES:")
			for eleve in eleves_maroc:
			    nom, prenom, ecole, classe, matieres = eleve
			    toutes_notes = []
			    for matiere in matieres:
			        toutes_notes.extend(matiere[1])
			    moyenne_generale = sum(toutes_notes) / len(toutes_notes)
			    mention = "Très Bien" if moyenne_generale >= 16 else \
			              "Bien" if moyenne_generale >= 14 else \
			              "Assez Bien" if moyenne_generale >= 12 else "Passable"
			    print(f"   {prenom} {nom}: {moyenne_generale:.2f}/20 - {mention}")
			
			# 2. Meilleur élève par matière
			print("\n? MEILLEURS ÉLÈVES PAR MATIÈRE:")
			
			# Collecter toutes les matières uniques
			toutes_matieres = set()
			for eleve in eleves_maroc:
			    for matiere in eleve[4]:
			        toutes_matieres.add(matiere[0])
			
			for matiere in toutes_matieres:
			    meilleur_eleve = None
			    meilleure_moyenne = 0
			    
			    for eleve in eleves_maroc:
			        nom, prenom, ecole, classe, matieres_eleve = eleve
			        
			        # Chercher la matière chez cet élève
			        for m in matieres_eleve:
			            if m[0] == matiere:
			                moyenne_matiere = sum(m[1]) / len(m[1])
			                if moyenne_matiere > meilleure_moyenne:
			                    meilleure_moyenne = moyenne_matiere
			                    meilleur_eleve = f"{prenom} {nom}"
			                break
			    
			    if meilleur_eleve:
			        print(f"   {matiere}: {meilleur_eleve} ({meilleure_moyenne:.2f}/20)")
			
			# 3. Performance par école
			print("\n? PERFORMANCE MOYENNE PAR ÉCOLE:")
			
			ecoles = {}
			for eleve in eleves_maroc:
			    nom, prenom, ecole, classe, matieres = eleve
			    
			    if ecole not in ecoles:
			        ecoles[ecole] = []
			    
			    # Calculer la moyenne générale de l'élève
			    toutes_notes = []
			    for matiere in matieres:
			        toutes_notes.extend(matiere[1])
			    moyenne_eleve = sum(toutes_notes) / len(toutes_notes)
			    ecoles[ecole].append(moyenne_eleve)
			
			for ecole, moyennes in ecoles.items():
			    moyenne_ecole = sum(moyennes) / len(moyennes)
			    print(f"   {ecole}: {moyenne_ecole:.2f}/20 ({len(moyennes)} élève(s))")
			
			# 4. Ajout d'un nouvel élève
			print("\n" + "="*50)
			print("=== AJOUT D'UN NOUVEL ÉLÈVE ===")
			
			nouvel_eleve = [
			    "Bennani", "Mehdi", "Lycée Hassan II", "Terminale Sciences",
			    [["Mathématiques", [14.5, 15.0, 13.5]],
			     ["Physique-Chimie", [16.0, 15.5, 14.0]],
			     ["SVT", [13.0, 14.5, 12.5]],
			     ["Philosophie", [15.5, 14.0]]]
			]
			
			eleves_maroc.append(nouvel_eleve)
			print("✅ Nouvel élève ajouté: Mehdi Bennani")
			
			# 5. Mise à jour des notes
			print("\n" + "="*50)
			print("=== MISE À JOUR DES NOTES ===")
			
			# Ajouter une nouvelle note en Mathématiques pour Amina Alami
			for eleve in eleves_maroc:
			    if eleve[0] == "Alami" and eleve[1] == "Amina":
			        for matiere in eleve[4]:
			            if matiere[0] == "Mathématiques":
			                matiere[1].append(18.0)  # Nouvelle note
			                nouvelle_moyenne = sum(matiere[1]) / len(matiere[1])
			                print(f"✅ Nouvelle note ajoutée pour Amina Alami en Mathématiques: 18.0")
			                print(f"   Nouvelle moyenne en Mathématiques: {nouvelle_moyenne:.2f}/20")
			                break
			        break
			
			# AFFICHAGE FINAL DU SYSTÈME
			print("\n" + "="*50)
			print("=== SYSTÈME COMPLET AVEC {len(eleves_maroc)} ÉLÈVES ===")
			print(f"Nombre total d'élèves dans le système: {len(eleves_maroc)}")
			
			# Compter le nombre total de notes
			total_notes = 0
			for eleve in eleves_maroc:
			    for matiere in eleve[4]:
			        total_notes += len(matiere[1])
			
			print(f"Nombre total de notes enregistrées: {total_notes}")
			
			# Élèves par classe
			classes = {}
			for eleve in eleves_maroc:
			    classe = eleve[3]
			    if classe not in classes:
			        classes[classe] = 0
			    classes[classe] += 1
			
			print(f"Répartition par classe: {classes}")

Applications avancées

Au-delà des cas d'usage classiques, les listes imbriquées permettent de modéliser des systèmes complexes comme les réseaux sociaux, les inventaires, ou les planifications.

applications_avancees.py
# APPLICATION 1: Réseau social d'étudiants marocains
			reseau_social = [
			    ["Amina Alami", "Casablanca", "Informatique",
			        ["Youssef Benani", "Fatima Zahra", "Karim Amrani"],  # Amis
			        [["Photo vacances", 156], ["Projet Python", 89]]  # Publications [titre, likes]
			    ],
			    ["Youssef Benani", "Rabat", "Médecine",
			        ["Amina Alami", "Mehdi Bennani"],
			        [["Stage hôpital", 234], ["Voyage Tanger", 167]]
			    ],
			    ["Fatima Zahra", "Fès", "Littérature",
			        ["Amina Alami", "Karim Amrani"],
			        [["Poème printemps", 312], ["Exposition art", 198]]
			    ]
			]
			
			print("=== RÉSEAU SOCIAL ÉTUDIANT MAROCAIN ===")
			
			# Statistiques du réseau
			total_utilisateurs = len(reseau_social)
			total_publications = 0
			total_likes = 0
			
			for utilisateur in reseau_social:
			    total_publications += len(utilisateur[4])
			    for publication in utilisateur[4]:
			        total_likes += publication[1]
			
			print(f"Utilisateurs: {total_utilisateurs}")
			print(f"Publications: {total_publications}")
			print(f"Likes totaux: {total_likes}")
			print(f"Moyenne de likes par publication: {total_likes/total_publications:.1f}")
			
			# APPLICATION 2: Inventaire de produits artisanaux
			inventaire_artisanal = [
			    ["Fès",
			        [["Zellige", 50, 150.0, "Artisan1"],   # [produit, quantité, prix, artisan]
			         ["Brodery", 30, 200.0, "Artisan2"],
			         ["Cuir", 25, 300.0, "Artisan3"]]
			    ],
			    ["Marrakech",
			        [["Tapis", 20, 500.0, "Artisan4"],
			         ["Poterie", 40, 80.0, "Artisan5"],
			         ["Lanterne", 35, 120.0, "Artisan6"]]
			    ],
			    ["Essaouira",
			        [["Marqueterie", 15, 250.0, "Artisan7"],
			         ["Argan", 60, 180.0, "Artisan8"]]
			    ]
			]
			
			print("\n" + "="*50)
			print("=== INVENTAIRE ARTISANAL MAROCAIN ===")
			
			# Valeur totale de l'inventaire par ville
			print("\n? VALEUR TOTALE PAR VILLE:")
			for ville in inventaire_artisanal:
			    nom_ville = ville[0]
			    valeur_totale = 0
			    
			    for produit in ville[1]:
			        valeur_totale += produit[1] * produit[2]  # quantité * prix
			    
			    print(f"  {nom_ville}: {valeur_totale:,.0f} DH")
			
			# Produit le plus cher par ville
			print("\n? PRODUIT LE PLUS CHER PAR VILLE:")
			for ville in inventaire_artisanal:
			    nom_ville = ville[0]
			    produits = ville[1]
			    
			    if produits:
			        produit_plus_cher = max(produits, key=lambda x: x[2])
			        print(f"  {nom_ville}: {produit_plus_cher[0]} - {produit_plus_cher[2]} DH")
			
			print(f"\n? Ces exemples démontrent la puissance des listes imbriquées")
			print(f"   pour modéliser des systèmes complexes du monde réel!")
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!